package com.ruoyi.system.domain;

import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.apache.commons.lang3.builder.ToStringBuilder;
import org.apache.commons.lang3.builder.ToStringStyle;
import com.ruoyi.common.annotation.Excel;
import com.ruoyi.common.core.domain.BaseEntity;

/**
 * 设备17信息对象 device_info_17
 * 
 * @author ruoyi
 * @date 2024-08-24
 */
public class DeviceInfo17 extends BaseEntity
{
    private static final long serialVersionUID = 1L;

    /** $column.columnComment */
    private Long id;

    /** 电网AB线电压 V */
    @Excel(name = "电网AB线电压 V")
    private Double abU;

    /** 电网BC线电压 V */
    @Excel(name = "电网BC线电压 V")
    private Double bcU;

    /** 电网CA线电压 V */
    @Excel(name = "电网CA线电压 V")
    private Double caU;

    /** A相电压（交流输出）V */
    @Excel(name = "A相电压", readConverterExp = "交=流输出")
    private Double aU;

    /** B相电压（交流输出）V */
    @Excel(name = "B相电压", readConverterExp = "交=流输出")
    private Double bU;

    /** C相电压（交流输出）V */
    @Excel(name = "C相电压", readConverterExp = "交=流输出")
    private Double cU;

    /** 电网A相电流(IA) A */
    @Excel(name = "电网A相电流(IA) A")
    private Double aI;

    /** 电网B相电流(IB) A */
    @Excel(name = "电网B相电流(IB) A")
    private Double bI;

    /** 电网C相电流(IC) A */
    @Excel(name = "电网C相电流(IC) A")
    private Double cI;

    /** 有功功率 kW */
    @Excel(name = "有功功率 kW")
    private Double activePower;

    /** 功率因数 无 */
    @Excel(name = "功率因数 无")
    private Double powerFactor;

    /** 有功电量(正向有功电度) kWh */
    @Excel(name = "有功电量(正向有功电度) kWh")
    private Double activeCap;

    /** 无功功率 kVar */
    @Excel(name = "无功功率 kVar")
    private Double reactivePower;

    /** 反向有功电度 kWh */
    @Excel(name = "反向有功电度 kWh")
    private Double reverseActiveCap;

    /** 正向无功电度 kWh */
    @Excel(name = "正向无功电度 kWh")
    private Double forwardReactiveCap;

    /** 反向无功电度 kWh */
    @Excel(name = "反向无功电度 kWh")
    private Double reverseReactiveCap;

    /** 有功功率PA kW */
    @Excel(name = "有功功率PA kW")
    private Double activePowerA;

    /** 有功功率PB kW */
    @Excel(name = "有功功率PB kW")
    private Double activePowerB;

    /** 有功功率PC kW */
    @Excel(name = "有功功率PC kW")
    private Double activePowerC;

    /** 无功功率QA kVar */
    @Excel(name = "无功功率QA kVar")
    private Double reactivePowerA;

    /** 无功功率QB kVar */
    @Excel(name = "无功功率QB kVar")
    private Double reactivePowerB;

    /** 无功功率QC kVar */
    @Excel(name = "无功功率QC kVar")
    private Double reactivePowerC;

    /** 总视在功率 kVA */
    @Excel(name = "总视在功率 kVA")
    private Double totalApparentPower;

    /** 电网频率 Hz */
    @Excel(name = "电网频率 Hz")
    private Double gridFrequency;

    /** 反向有功电度（峰）kWh */
    @Excel(name = "反向有功电度", readConverterExp = "峰=")
    private Double reverseActivePeak;

    /** 反向有功电度（平）kWh */
    @Excel(name = "反向有功电度", readConverterExp = "平=")
    private Double reverseActivePower;

    /** 反向有功电度（谷）kWh */
    @Excel(name = "反向有功电度", readConverterExp = "谷=")
    private Double reverseActiveValley;

    /** 反向有功电度（尖峰）kWh */
    @Excel(name = "反向有功电度", readConverterExp = "尖=峰")
    private Double reverseActiveTop;

    /** 正向有功电度（峰）kWh */
    @Excel(name = "正向有功电度", readConverterExp = "峰=")
    private Double positiveActivePeak;

    /** 正向有功电度（平）kWh */
    @Excel(name = "正向有功电度", readConverterExp = "平=")
    private Double positiveActivePower;

    /** 正向有功电度（谷）kWh */
    @Excel(name = "正向有功电度", readConverterExp = "谷=")
    private Double positiveActiveValley;

    /** 正向有功电度（尖峰）kWh */
    @Excel(name = "正向有功电度", readConverterExp = "尖=峰")
    private Double positiveActiveTop;

    /** 反向无功电度（峰）kVar */
    @Excel(name = "反向无功电度", readConverterExp = "峰=")
    private Double reverseReactivePeak;

    /** 反向无功电度（平）kVar */
    @Excel(name = "反向无功电度", readConverterExp = "平=")
    private Double reverseReactivePower;

    /** 反向无功电度（谷）kVar */
    @Excel(name = "反向无功电度", readConverterExp = "谷=")
    private Double reverseReactiveValley;

    /** 反向无功电度（尖峰）kVar */
    @Excel(name = "反向无功电度", readConverterExp = "尖=峰")
    private Double reverseReactiveTop;

    /** 正向无功电度（峰）kVar */
    @Excel(name = "正向无功电度", readConverterExp = "峰=")
    private Double positiveReactivePeak;

    /** 正向无功电度（平）kVar */
    @Excel(name = "正向无功电度", readConverterExp = "平=")
    private Double positiveReactivePower;

    /** 正向无功电度（谷）kVar */
    @Excel(name = "正向无功电度", readConverterExp = "谷=")
    private Double positiveReactiveValley;

    /** 正向无功电度（尖峰）kVar */
    @Excel(name = "正向无功电度", readConverterExp = "尖=峰")
    private Double positiveReactiveTop;

    /** $column.columnComment */
    @Excel(name = "${comment}", readConverterExp = "$column.readConverterExp()")
    private Long devId;

    /** $column.columnComment */
    @Excel(name = "${comment}", readConverterExp = "$column.readConverterExp()")
    private Date collectTime;

    /** 记录创建时间 */
    @JsonFormat(pattern = "yyyy-MM-dd")
    @Excel(name = "记录创建时间", width = 30, dateFormat = "yyyy-MM-dd")
    private Date createdAt;

    public void setId(Long id) 
    {
        this.id = id;
    }

    public Long getId() 
    {
        return id;
    }
    public void setAbU(Double abU) 
    {
        this.abU = abU;
    }

    public Double getAbU() 
    {
        return abU;
    }
    public void setBcU(Double bcU) 
    {
        this.bcU = bcU;
    }

    public Double getBcU() 
    {
        return bcU;
    }
    public void setCaU(Double caU) 
    {
        this.caU = caU;
    }

    public Double getCaU() 
    {
        return caU;
    }
    public void setAU(Double aU) 
    {
        this.aU = aU;
    }

    public Double getAU() 
    {
        return aU;
    }
    public void setBU(Double bU) 
    {
        this.bU = bU;
    }

    public Double getBU() 
    {
        return bU;
    }
    public void setCU(Double cU) 
    {
        this.cU = cU;
    }

    public Double getCU() 
    {
        return cU;
    }
    public void setAI(Double aI) 
    {
        this.aI = aI;
    }

    public Double getAI() 
    {
        return aI;
    }
    public void setBI(Double bI) 
    {
        this.bI = bI;
    }

    public Double getBI() 
    {
        return bI;
    }
    public void setCI(Double cI) 
    {
        this.cI = cI;
    }

    public Double getCI() 
    {
        return cI;
    }
    public void setActivePower(Double activePower) 
    {
        this.activePower = activePower;
    }

    public Double getActivePower() 
    {
        return activePower;
    }
    public void setPowerFactor(Double powerFactor) 
    {
        this.powerFactor = powerFactor;
    }

    public Double getPowerFactor() 
    {
        return powerFactor;
    }
    public void setActiveCap(Double activeCap) 
    {
        this.activeCap = activeCap;
    }

    public Double getActiveCap() 
    {
        return activeCap;
    }
    public void setReactivePower(Double reactivePower) 
    {
        this.reactivePower = reactivePower;
    }

    public Double getReactivePower() 
    {
        return reactivePower;
    }
    public void setReverseActiveCap(Double reverseActiveCap) 
    {
        this.reverseActiveCap = reverseActiveCap;
    }

    public Double getReverseActiveCap() 
    {
        return reverseActiveCap;
    }
    public void setForwardReactiveCap(Double forwardReactiveCap) 
    {
        this.forwardReactiveCap = forwardReactiveCap;
    }

    public Double getForwardReactiveCap() 
    {
        return forwardReactiveCap;
    }
    public void setReverseReactiveCap(Double reverseReactiveCap) 
    {
        this.reverseReactiveCap = reverseReactiveCap;
    }

    public Double getReverseReactiveCap() 
    {
        return reverseReactiveCap;
    }
    public void setActivePowerA(Double activePowerA) 
    {
        this.activePowerA = activePowerA;
    }

    public Double getActivePowerA() 
    {
        return activePowerA;
    }
    public void setActivePowerB(Double activePowerB) 
    {
        this.activePowerB = activePowerB;
    }

    public Double getActivePowerB() 
    {
        return activePowerB;
    }
    public void setActivePowerC(Double activePowerC) 
    {
        this.activePowerC = activePowerC;
    }

    public Double getActivePowerC() 
    {
        return activePowerC;
    }
    public void setReactivePowerA(Double reactivePowerA) 
    {
        this.reactivePowerA = reactivePowerA;
    }

    public Double getReactivePowerA() 
    {
        return reactivePowerA;
    }
    public void setReactivePowerB(Double reactivePowerB) 
    {
        this.reactivePowerB = reactivePowerB;
    }

    public Double getReactivePowerB() 
    {
        return reactivePowerB;
    }
    public void setReactivePowerC(Double reactivePowerC) 
    {
        this.reactivePowerC = reactivePowerC;
    }

    public Double getReactivePowerC() 
    {
        return reactivePowerC;
    }
    public void setTotalApparentPower(Double totalApparentPower) 
    {
        this.totalApparentPower = totalApparentPower;
    }

    public Double getTotalApparentPower() 
    {
        return totalApparentPower;
    }
    public void setGridFrequency(Double gridFrequency) 
    {
        this.gridFrequency = gridFrequency;
    }

    public Double getGridFrequency() 
    {
        return gridFrequency;
    }
    public void setReverseActivePeak(Double reverseActivePeak) 
    {
        this.reverseActivePeak = reverseActivePeak;
    }

    public Double getReverseActivePeak() 
    {
        return reverseActivePeak;
    }
    public void setReverseActivePower(Double reverseActivePower) 
    {
        this.reverseActivePower = reverseActivePower;
    }

    public Double getReverseActivePower() 
    {
        return reverseActivePower;
    }
    public void setReverseActiveValley(Double reverseActiveValley) 
    {
        this.reverseActiveValley = reverseActiveValley;
    }

    public Double getReverseActiveValley() 
    {
        return reverseActiveValley;
    }
    public void setReverseActiveTop(Double reverseActiveTop) 
    {
        this.reverseActiveTop = reverseActiveTop;
    }

    public Double getReverseActiveTop() 
    {
        return reverseActiveTop;
    }
    public void setPositiveActivePeak(Double positiveActivePeak) 
    {
        this.positiveActivePeak = positiveActivePeak;
    }

    public Double getPositiveActivePeak() 
    {
        return positiveActivePeak;
    }
    public void setPositiveActivePower(Double positiveActivePower) 
    {
        this.positiveActivePower = positiveActivePower;
    }

    public Double getPositiveActivePower() 
    {
        return positiveActivePower;
    }
    public void setPositiveActiveValley(Double positiveActiveValley) 
    {
        this.positiveActiveValley = positiveActiveValley;
    }

    public Double getPositiveActiveValley() 
    {
        return positiveActiveValley;
    }
    public void setPositiveActiveTop(Double positiveActiveTop) 
    {
        this.positiveActiveTop = positiveActiveTop;
    }

    public Double getPositiveActiveTop() 
    {
        return positiveActiveTop;
    }
    public void setReverseReactivePeak(Double reverseReactivePeak) 
    {
        this.reverseReactivePeak = reverseReactivePeak;
    }

    public Double getReverseReactivePeak() 
    {
        return reverseReactivePeak;
    }
    public void setReverseReactivePower(Double reverseReactivePower) 
    {
        this.reverseReactivePower = reverseReactivePower;
    }

    public Double getReverseReactivePower() 
    {
        return reverseReactivePower;
    }
    public void setReverseReactiveValley(Double reverseReactiveValley) 
    {
        this.reverseReactiveValley = reverseReactiveValley;
    }

    public Double getReverseReactiveValley() 
    {
        return reverseReactiveValley;
    }
    public void setReverseReactiveTop(Double reverseReactiveTop) 
    {
        this.reverseReactiveTop = reverseReactiveTop;
    }

    public Double getReverseReactiveTop() 
    {
        return reverseReactiveTop;
    }
    public void setPositiveReactivePeak(Double positiveReactivePeak) 
    {
        this.positiveReactivePeak = positiveReactivePeak;
    }

    public Double getPositiveReactivePeak() 
    {
        return positiveReactivePeak;
    }
    public void setPositiveReactivePower(Double positiveReactivePower) 
    {
        this.positiveReactivePower = positiveReactivePower;
    }

    public Double getPositiveReactivePower() 
    {
        return positiveReactivePower;
    }
    public void setPositiveReactiveValley(Double positiveReactiveValley) 
    {
        this.positiveReactiveValley = positiveReactiveValley;
    }

    public Double getPositiveReactiveValley() 
    {
        return positiveReactiveValley;
    }
    public void setPositiveReactiveTop(Double positiveReactiveTop) 
    {
        this.positiveReactiveTop = positiveReactiveTop;
    }

    public Double getPositiveReactiveTop() 
    {
        return positiveReactiveTop;
    }
    public void setDevId(Long devId) 
    {
        this.devId = devId;
    }

    public Long getDevId() 
    {
        return devId;
    }
    public void setCollectTime(Date collectTime) 
    {
        this.collectTime = collectTime;
    }

    public Date getCollectTime() 
    {
        return collectTime;
    }
    public void setCreatedAt(Date createdAt) 
    {
        this.createdAt = createdAt;
    }

    public Date getCreatedAt() 
    {
        return createdAt;
    }

    @Override
    public String toString() {
        return new ToStringBuilder(this,ToStringStyle.MULTI_LINE_STYLE)
            .append("id", getId())
            .append("abU", getAbU())
            .append("bcU", getBcU())
            .append("caU", getCaU())
            .append("aU", getAU())
            .append("bU", getBU())
            .append("cU", getCU())
            .append("aI", getAI())
            .append("bI", getBI())
            .append("cI", getCI())
            .append("activePower", getActivePower())
            .append("powerFactor", getPowerFactor())
            .append("activeCap", getActiveCap())
            .append("reactivePower", getReactivePower())
            .append("reverseActiveCap", getReverseActiveCap())
            .append("forwardReactiveCap", getForwardReactiveCap())
            .append("reverseReactiveCap", getReverseReactiveCap())
            .append("activePowerA", getActivePowerA())
            .append("activePowerB", getActivePowerB())
            .append("activePowerC", getActivePowerC())
            .append("reactivePowerA", getReactivePowerA())
            .append("reactivePowerB", getReactivePowerB())
            .append("reactivePowerC", getReactivePowerC())
            .append("totalApparentPower", getTotalApparentPower())
            .append("gridFrequency", getGridFrequency())
            .append("reverseActivePeak", getReverseActivePeak())
            .append("reverseActivePower", getReverseActivePower())
            .append("reverseActiveValley", getReverseActiveValley())
            .append("reverseActiveTop", getReverseActiveTop())
            .append("positiveActivePeak", getPositiveActivePeak())
            .append("positiveActivePower", getPositiveActivePower())
            .append("positiveActiveValley", getPositiveActiveValley())
            .append("positiveActiveTop", getPositiveActiveTop())
            .append("reverseReactivePeak", getReverseReactivePeak())
            .append("reverseReactivePower", getReverseReactivePower())
            .append("reverseReactiveValley", getReverseReactiveValley())
            .append("reverseReactiveTop", getReverseReactiveTop())
            .append("positiveReactivePeak", getPositiveReactivePeak())
            .append("positiveReactivePower", getPositiveReactivePower())
            .append("positiveReactiveValley", getPositiveReactiveValley())
            .append("positiveReactiveTop", getPositiveReactiveTop())
            .append("devId", getDevId())
            .append("collectTime", getCollectTime())
            .append("createdAt", getCreatedAt())
            .toString();
    }
}
